class Person {
    //静态类
    static uName: string = '夏天'
    constructor() {}
    //静态方法
    static sayHi() {
        console.log('hello world')
    }
}

//静态属性和静态方法的调用
Person.uName
Person.sayHi()

//抽象类
//abstract 修饰
// 多态:父类定义一个方法不去实现，让继承它的子类去实现  每一个子类有不同的表现
abstract class Animal {
    public aName: string

    constructor(aName: string) {
        this.aName = aName
    }
    // 抽象方法
    abstract voice()
}

class Dog extends Animal {
    voice() {
        console.log(this.aName+',汪汪')
    }
}
class Cat extends Animal {
    voice() {
        console.log(this.aName+',喵喵')
    }
}

// 先声明变量是Animal类型，具体是Dog还是Cat，在new 对象时才知道
//如果是Dog，Dog类中的voice方法；如果是Cat，Cat类中的voice方法，这就是多态！！
var animal:Animal;

animal = new Dog('小汪')
animal.voice()

animal = new Cat('小苗')
animal.voice()

//剩余参数
function info(x:string, ...args) {
    console.log(x)
    console.log(args)
}

info('小红','小明','小黑')

//函数重载
function add(x:string, y: string):string
function add(x:number, y: number): number

function add(x:string | number, y:string|number) {
    if(typeof x === 'string' && typeof y === 'string') {
        return x+y
    }else if(typeof x === 'number' && typeof y === 'number') {
        return x+y
    }
}

//调用函数
add('东方','不败') //东方不败
add(2, 2)   //4

//使用泛型
function createArray<T> (value: T, count:number){
    const arr: Array<T> = []
    for(let i:number = 0; i < count; i++) {
        arr.push(value)
    }
    return arr
}
const strArr:string[] = createArray('哈', 3)
const numArr: number[] = createArray(1, 3)
console.log(strArr) //[ '哈', '哈', '哈' ]
console.log(numArr) // [ 1, 1, 1 ]